home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / managers / NativeDragManagerImpl.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  18.4 KB  |  498 lines
  1. package mx.managers
  2. {
  3.    import flash.desktop.Clipboard;
  4.    import flash.desktop.NativeDragManager;
  5.    import flash.desktop.NativeDragOptions;
  6.    import flash.display.BitmapData;
  7.    import flash.display.DisplayObject;
  8.    import flash.display.InteractiveObject;
  9.    import flash.events.Event;
  10.    import flash.events.IEventDispatcher;
  11.    import flash.events.MouseEvent;
  12.    import flash.events.NativeDragEvent;
  13.    import flash.geom.Point;
  14.    import flash.system.Capabilities;
  15.    import mx.core.DragSource;
  16.    import mx.core.IFlexDisplayObject;
  17.    import mx.core.IUIComponent;
  18.    import mx.core.UIComponentGlobals;
  19.    import mx.core.mx_internal;
  20.    import mx.events.DragEvent;
  21.    import mx.events.FlexEvent;
  22.    import mx.events.InterDragManagerEvent;
  23.    import mx.events.InterManagerRequest;
  24.    import mx.managers.dragClasses.DragProxy;
  25.    import mx.styles.CSSStyleDeclaration;
  26.    import mx.styles.StyleManager;
  27.    
  28.    use namespace mx_internal;
  29.    
  30.    public class NativeDragManagerImpl implements IDragManager
  31.    {
  32.       private static var sm:ISystemManager;
  33.       
  34.       private static var instance:IDragManager;
  35.       
  36.       private var _dragImage:IFlexDisplayObject;
  37.       
  38.       private var sandboxRoot:IEventDispatcher;
  39.       
  40.       private var _relatedObject:InteractiveObject;
  41.       
  42.       private var _allowedActions:NativeDragOptions;
  43.       
  44.       private var _action:String;
  45.       
  46.       private var _clipboard:Clipboard;
  47.       
  48.       public var dragProxy:DragProxy;
  49.       
  50.       private var _dragInitiator:IUIComponent;
  51.       
  52.       private var mouseIsDown:Boolean = false;
  53.       
  54.       private var _offset:Point;
  55.       
  56.       private var _allowMove:Boolean;
  57.       
  58.       public function NativeDragManagerImpl()
  59.       {
  60.          super();
  61.          if(instance)
  62.          {
  63.             throw new Error("Instance already exists.");
  64.          }
  65.          mx_internal::registerSystemManager(sm);
  66.          sandboxRoot = sm.getSandboxRoot();
  67.          sandboxRoot.addEventListener(InterDragManagerEvent.DISPATCH_DRAG_EVENT,marshalDispatchEventHandler,false,0,true);
  68.          sandboxRoot.addEventListener(InterManagerRequest.DRAG_MANAGER_REQUEST,marshalDragManagerHandler,false,0,true);
  69.          var _loc1_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  70.          _loc1_.name = "update";
  71.          sandboxRoot.dispatchEvent(_loc1_);
  72.       }
  73.       
  74.       public static function getInstance() : IDragManager
  75.       {
  76.          if(!instance)
  77.          {
  78.             sm = SystemManagerGlobals.topLevelSystemManagers[0];
  79.             instance = new NativeDragManagerImpl();
  80.          }
  81.          return instance;
  82.       }
  83.       
  84.       private function marshalDispatchEventHandler(param1:Event) : void
  85.       {
  86.          if(param1 is InterDragManagerEvent)
  87.          {
  88.             return;
  89.          }
  90.          var _loc2_:Object = param1;
  91.          var _loc3_:DisplayObject = SystemManager.getSWFRoot(_loc2_.dropTarget);
  92.          if(!_loc3_)
  93.          {
  94.             return;
  95.          }
  96.          var _loc4_:DragEvent = new DragEvent(_loc2_.dragEventType,_loc2_.bubbles,_loc2_.cancelable);
  97.          _loc4_.localX = _loc2_.localX;
  98.          _loc4_.localY = _loc2_.localY;
  99.          _loc4_.action = _loc2_.action;
  100.          _loc4_.ctrlKey = _loc2_.ctrlKey;
  101.          _loc4_.altKey = _loc2_.altKey;
  102.          _loc4_.shiftKey = _loc2_.shiftKey;
  103.          _loc4_.draggedItem = _loc2_.draggedItem;
  104.          _loc4_.dragSource = new DragSource();
  105.          var _loc5_:Array = _loc2_.dragSource.formats;
  106.          var _loc6_:int = int(_loc5_.length);
  107.          var _loc7_:int = 0;
  108.          while(_loc7_ < _loc6_)
  109.          {
  110.             _loc4_.dragSource.addData(_loc2_.dragSource.dataForFormat(_loc5_[_loc7_]),_loc5_[_loc7_]);
  111.             _loc7_++;
  112.          }
  113.          if(!_loc2_.dropTarget.dispatchEvent(_loc4_))
  114.          {
  115.             param1.preventDefault();
  116.          }
  117.       }
  118.       
  119.       public function getFeedback() : String
  120.       {
  121.          var _loc1_:InterManagerRequest = null;
  122.          if(!isDragging)
  123.          {
  124.             _loc1_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  125.             _loc1_.name = "getFeedback";
  126.             sandboxRoot.dispatchEvent(_loc1_);
  127.             return _loc1_.value as String;
  128.          }
  129.          return NativeDragManager.dropAction;
  130.       }
  131.       
  132.       private function marshalDragManagerHandler(param1:Event) : void
  133.       {
  134.          var _loc3_:InteractiveObject = null;
  135.          var _loc4_:InterManagerRequest = null;
  136.          if(param1 is InterManagerRequest)
  137.          {
  138.             return;
  139.          }
  140.          var _loc2_:Object = param1;
  141.          switch(_loc2_.name)
  142.          {
  143.             case "isDragging":
  144.                break;
  145.             case "acceptDragDrop":
  146.                if(isDragging)
  147.                {
  148.                   _loc3_ = _loc2_.value as InteractiveObject;
  149.                   if(_loc3_)
  150.                   {
  151.                      NativeDragManager.acceptDragDrop(_loc3_);
  152.                   }
  153.                }
  154.                break;
  155.             case "showFeedback":
  156.                if(isDragging)
  157.                {
  158.                   showFeedback(_loc2_.value);
  159.                }
  160.                break;
  161.             case "getFeedback":
  162.                if(isDragging)
  163.                {
  164.                   _loc2_.value = getFeedback();
  165.                }
  166.                break;
  167.             case "endDrag":
  168.                endDrag();
  169.                break;
  170.             case "update":
  171.                if(isDragging)
  172.                {
  173.                   _loc4_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  174.                   _loc4_.name = "isDragging";
  175.                   _loc4_.value = true;
  176.                   sandboxRoot.dispatchEvent(_loc4_);
  177.                }
  178.          }
  179.       }
  180.       
  181.       mx_internal function unregisterSystemManager(param1:ISystemManager) : void
  182.       {
  183.          if(param1.isTopLevel())
  184.          {
  185.             param1.removeEventListener(MouseEvent.MOUSE_DOWN,sm_mouseDownHandler);
  186.             param1.removeEventListener(MouseEvent.MOUSE_UP,sm_mouseUpHandler);
  187.          }
  188.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_ENTER,nativeDragEventHandler,true);
  189.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_COMPLETE,nativeDragEventHandler,true);
  190.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_DROP,nativeDragEventHandler,true);
  191.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_EXIT,nativeDragEventHandler,true);
  192.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_OVER,nativeDragEventHandler,true);
  193.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_START,nativeDragEventHandler,true);
  194.       }
  195.       
  196.       public function get isDragging() : Boolean
  197.       {
  198.          return NativeDragManager.isDragging;
  199.       }
  200.       
  201.       mx_internal function registerSystemManager(param1:ISystemManager) : void
  202.       {
  203.          if(param1.isTopLevel())
  204.          {
  205.             param1.addEventListener(MouseEvent.MOUSE_DOWN,sm_mouseDownHandler);
  206.             param1.addEventListener(MouseEvent.MOUSE_UP,sm_mouseUpHandler);
  207.          }
  208.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_ENTER,nativeDragEventHandler,true);
  209.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_COMPLETE,nativeDragEventHandler,true);
  210.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_DROP,nativeDragEventHandler,true);
  211.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_EXIT,nativeDragEventHandler,true);
  212.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_OVER,nativeDragEventHandler,true);
  213.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_START,nativeDragEventHandler,true);
  214.       }
  215.       
  216.       private function sm_mouseUpHandler(param1:MouseEvent) : void
  217.       {
  218.          mouseIsDown = false;
  219.       }
  220.       
  221.       public function doDrag(param1:IUIComponent, param2:DragSource, param3:MouseEvent, param4:IFlexDisplayObject = null, param5:Number = 0, param6:Number = 0, param7:Number = 0.5, param8:Boolean = true) : void
  222.       {
  223.          var _loc9_:Number = NaN;
  224.          var _loc10_:Number = NaN;
  225.          var _loc13_:String = null;
  226.          var _loc14_:Object = null;
  227.          var _loc15_:CSSStyleDeclaration = null;
  228.          var _loc16_:Class = null;
  229.          if(isDragging)
  230.          {
  231.             return;
  232.          }
  233.          if(!(param3.type == MouseEvent.MOUSE_DOWN || param3.type == MouseEvent.CLICK || mouseIsDown || param3.buttonDown))
  234.          {
  235.             return;
  236.          }
  237.          var _loc11_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  238.          _loc11_.name = "isDragging";
  239.          _loc11_.value = true;
  240.          sandboxRoot.dispatchEvent(_loc11_);
  241.          _loc11_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  242.          _loc11_.name = "mouseShield";
  243.          _loc11_.value = true;
  244.          sandboxRoot.dispatchEvent(_loc11_);
  245.          _clipboard = new Clipboard();
  246.          _dragInitiator = param1;
  247.          _offset = new Point(param5,param6);
  248.          _allowMove = param8;
  249.          _offset.y -= InteractiveObject(param1).mouseY;
  250.          _offset.x -= InteractiveObject(param1).mouseX;
  251.          _allowedActions = new NativeDragOptions();
  252.          _allowedActions.allowCopy = true;
  253.          _allowedActions.allowLink = true;
  254.          _allowedActions.allowMove = param8;
  255.          var _loc12_:int = 0;
  256.          while(_loc12_ < param2.formats.length)
  257.          {
  258.             _loc13_ = param2.formats[_loc12_] as String;
  259.             _loc14_ = param2.dataForFormat(_loc13_);
  260.             _clipboard.setData(_loc13_,_loc14_);
  261.             _loc12_++;
  262.          }
  263.          if(!param4)
  264.          {
  265.             _loc15_ = StyleManager.getStyleDeclaration("DragManager");
  266.             _loc16_ = _loc15_.getStyle("defaultDragImageSkin");
  267.             param4 = new _loc16_();
  268.             _loc9_ = !!param1 ? Number(param1.width) : 0;
  269.             _loc10_ = !!param1 ? Number(param1.height) : 0;
  270.             if(param4 is IFlexDisplayObject)
  271.             {
  272.                IFlexDisplayObject(param4).setActualSize(_loc9_,_loc10_);
  273.             }
  274.          }
  275.          else
  276.          {
  277.             _loc9_ = Number(param4.width);
  278.             _loc10_ = Number(param4.height);
  279.          }
  280.          _dragImage = param4;
  281.          if(param4 is IUIComponent && param4 is ILayoutManagerClient && !ILayoutManagerClient(param4).initialized && Boolean(param1))
  282.          {
  283.             param4.addEventListener(FlexEvent.UPDATE_COMPLETE,initiateDrag);
  284.             param1.systemManager.popUpChildren.addChild(DisplayObject(param4));
  285.             if(param4 is ILayoutManagerClient)
  286.             {
  287.                UIComponentGlobals.mx_internal::layoutManager.validateClient(ILayoutManagerClient(param4),true);
  288.             }
  289.             if(param4 is IUIComponent)
  290.             {
  291.                param4.setActualSize(_loc9_,_loc10_);
  292.                _loc9_ = Number((param4 as IUIComponent).getExplicitOrMeasuredWidth());
  293.                _loc10_ = Number((param4 as IUIComponent).getExplicitOrMeasuredHeight());
  294.             }
  295.             else
  296.             {
  297.                _loc9_ = Number(param4.measuredWidth);
  298.                _loc10_ = Number(param4.measuredHeight);
  299.             }
  300.             if(param4 is ILayoutManagerClient)
  301.             {
  302.                UIComponentGlobals.mx_internal::layoutManager.validateClient(ILayoutManagerClient(param4));
  303.             }
  304.             return;
  305.          }
  306.          initiateDrag(null,false);
  307.       }
  308.       
  309.       private function isSameOrChildApplicationDomain(param1:Object) : Boolean
  310.       {
  311.          var _loc2_:DisplayObject = SystemManager.getSWFRoot(param1);
  312.          return _loc2_ != null;
  313.       }
  314.       
  315.       public function showFeedback(param1:String) : void
  316.       {
  317.          var _loc2_:InterManagerRequest = null;
  318.          if(isDragging)
  319.          {
  320.             if(param1 == DragManager.MOVE && !_allowedActions.allowMove)
  321.             {
  322.                return;
  323.             }
  324.             if(param1 == DragManager.COPY && !_allowedActions.allowCopy)
  325.             {
  326.                return;
  327.             }
  328.             if(param1 == DragManager.LINK && !_allowedActions.allowLink)
  329.             {
  330.                return;
  331.             }
  332.             NativeDragManager.dropAction = param1;
  333.          }
  334.          else
  335.          {
  336.             _loc2_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  337.             _loc2_.name = "showFeedback";
  338.             _loc2_.value = param1;
  339.             sandboxRoot.dispatchEvent(_loc2_);
  340.          }
  341.       }
  342.       
  343.       public function acceptDragDrop(param1:IUIComponent) : void
  344.       {
  345.          var _loc2_:InteractiveObject = null;
  346.          var _loc3_:InterManagerRequest = null;
  347.          if(isDragging)
  348.          {
  349.             _loc2_ = param1 as InteractiveObject;
  350.             if(_loc2_)
  351.             {
  352.                NativeDragManager.acceptDragDrop(_loc2_);
  353.             }
  354.          }
  355.          else
  356.          {
  357.             _loc3_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  358.             _loc3_.name = "acceptDragDrop";
  359.             _loc3_.value = param1;
  360.             sandboxRoot.dispatchEvent(_loc3_);
  361.          }
  362.       }
  363.       
  364.       private function initiateDrag(param1:FlexEvent, param2:Boolean = true) : void
  365.       {
  366.          var _loc3_:BitmapData = null;
  367.          if(param2)
  368.          {
  369.             _dragImage.removeEventListener(FlexEvent.UPDATE_COMPLETE,initiateDrag);
  370.          }
  371.          if(Boolean(_dragImage.width) && Boolean(_dragImage.height))
  372.          {
  373.             _loc3_ = new BitmapData(_dragImage.width,_dragImage.height,true,0);
  374.          }
  375.          else
  376.          {
  377.             _loc3_ = new BitmapData(1,1,true,0);
  378.          }
  379.          _loc3_.draw(_dragImage);
  380.          if(param2 && _dragImage is IUIComponent && Boolean(_dragInitiator))
  381.          {
  382.             _dragInitiator.systemManager.popUpChildren.removeChild(DisplayObject(_dragImage));
  383.          }
  384.          NativeDragManager.doDrag(InteractiveObject(_dragInitiator),_clipboard,_loc3_,_offset,_allowedActions);
  385.       }
  386.       
  387.       public function endDrag() : void
  388.       {
  389.          var _loc1_:InterManagerRequest = null;
  390.          _loc1_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  391.          _loc1_.name = "mouseShield";
  392.          _loc1_.value = false;
  393.          sandboxRoot.dispatchEvent(_loc1_);
  394.          _loc1_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  395.          _loc1_.name = "isDragging";
  396.          _loc1_.value = false;
  397.          sandboxRoot.dispatchEvent(_loc1_);
  398.       }
  399.       
  400.       private function sm_mouseDownHandler(param1:MouseEvent) : void
  401.       {
  402.          mouseIsDown = true;
  403.       }
  404.       
  405.       private function _dispatchDragEvent(param1:DisplayObject, param2:DragEvent) : void
  406.       {
  407.          var _loc3_:InterManagerRequest = null;
  408.          var _loc4_:InterDragManagerEvent = null;
  409.          if(isSameOrChildApplicationDomain(param1))
  410.          {
  411.             param1.dispatchEvent(param2);
  412.          }
  413.          else
  414.          {
  415.             _loc3_ = new InterManagerRequest(InterManagerRequest.INIT_MANAGER_REQUEST);
  416.             _loc3_.name = "mx.managers.IDragManagerImpl";
  417.             sandboxRoot.dispatchEvent(_loc3_);
  418.             _loc4_ = new InterDragManagerEvent(InterDragManagerEvent.DISPATCH_DRAG_EVENT,false,false,param2.localX,param2.localY,param2.relatedObject,param2.ctrlKey,param2.altKey,param2.shiftKey,param2.buttonDown,param2.delta,param1,param2.type,param2.dragInitiator,param2.dragSource,param2.action,param2.draggedItem);
  419.             sandboxRoot.dispatchEvent(_loc4_);
  420.          }
  421.       }
  422.       
  423.       private function nativeDragEventHandler(param1:NativeDragEvent) : void
  424.       {
  425.          var _loc8_:String = null;
  426.          var _loc9_:Object = null;
  427.          var _loc10_:InterManagerRequest = null;
  428.          var _loc13_:int = 0;
  429.          var _loc2_:String = param1.type.charAt(6).toLowerCase() + param1.type.substr(7);
  430.          var _loc3_:DragSource = new DragSource();
  431.          var _loc4_:DisplayObject = param1.target as DisplayObject;
  432.          var _loc5_:Clipboard = param1.clipboard;
  433.          var _loc6_:Array = _loc5_.formats;
  434.          var _loc7_:int = int(_loc6_.length);
  435.          _allowedActions = param1.allowedActions;
  436.          var _loc11_:Boolean = false;
  437.          if(Capabilities.os.substring(0,3) == "Mac")
  438.          {
  439.             _loc11_ = Boolean(param1.commandKey);
  440.          }
  441.          else
  442.          {
  443.             _loc11_ = Boolean(param1.controlKey);
  444.          }
  445.          if(NativeDragManager.dragInitiator != null)
  446.          {
  447.             NativeDragManager.dropAction = _loc11_ || !_allowMove ? DragManager.COPY : DragManager.MOVE;
  448.          }
  449.          if(param1.type != NativeDragEvent.NATIVE_DRAG_EXIT)
  450.          {
  451.             _loc13_ = 0;
  452.             while(_loc13_ < _loc7_)
  453.             {
  454.                _loc8_ = _loc6_[_loc13_];
  455.                if(_loc5_.hasFormat(_loc8_))
  456.                {
  457.                   _loc9_ = _loc5_.getData(_loc8_);
  458.                   _loc3_.addData(_loc9_,_loc8_);
  459.                }
  460.                _loc13_++;
  461.             }
  462.          }
  463.          if(param1.type == NativeDragEvent.NATIVE_DRAG_DROP)
  464.          {
  465.             _relatedObject = param1.target as InteractiveObject;
  466.          }
  467.          var _loc12_:DragEvent = new DragEvent(_loc2_,false,param1.cancelable,NativeDragManager.dragInitiator as IUIComponent,_loc3_,param1.dropAction,_loc11_,param1.altKey,param1.shiftKey);
  468.          _loc12_.buttonDown = param1.buttonDown;
  469.          _loc12_.delta = param1.delta;
  470.          _loc12_.localX = param1.localX;
  471.          _loc12_.localY = param1.localY;
  472.          if(_loc2_ == DragEvent.DRAG_COMPLETE)
  473.          {
  474.             _loc12_.relatedObject = _relatedObject;
  475.          }
  476.          else
  477.          {
  478.             _loc12_.relatedObject = param1.relatedObject;
  479.          }
  480.          _dispatchDragEvent(_loc4_,_loc12_);
  481.          if(_loc2_ == DragEvent.DRAG_COMPLETE)
  482.          {
  483.             if(sm == sandboxRoot)
  484.             {
  485.                endDrag();
  486.             }
  487.             else
  488.             {
  489.                _loc10_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  490.                _loc10_.name = "endDrag";
  491.                sandboxRoot.dispatchEvent(_loc10_);
  492.             }
  493.          }
  494.       }
  495.    }
  496. }
  497.  
  498.